/**
 * This is a generated class and is not intended for modfication.  To customize behavior
 * of this value object you may modify the generated sub-class of this class - PlanAdjustApplication.as.
 */

package valueObjects
{
import com.adobe.fiber.services.IFiberManagingService;
import com.adobe.fiber.valueobjects.IValueObject;
import flash.events.Event;
import flash.events.EventDispatcher;
import mx.events.PropertyChangeEvent;
import valueObjects.Timestamp;

import flash.net.registerClassAlias;
import flash.net.getClassByAlias;
import com.adobe.fiber.core.model_internal;
import com.adobe.fiber.valueobjects.IPropertyIterator;
import com.adobe.fiber.valueobjects.AvailablePropertyIterator;

use namespace model_internal;

[ExcludeClass]
public class _Super_PlanAdjustApplication extends flash.events.EventDispatcher implements com.adobe.fiber.valueobjects.IValueObject
{
    model_internal static function initRemoteClassAliasSingle(cz:Class) : void 
    {
        try 
        {
            if (flash.net.getClassByAlias("edu.whu.bsrms.plan.model.PlanAdjustApplication") == null)
            {
                flash.net.registerClassAlias("edu.whu.bsrms.plan.model.PlanAdjustApplication", cz);
            } 
        }
        catch (e:Error) 
        {
            flash.net.registerClassAlias("edu.whu.bsrms.plan.model.PlanAdjustApplication", cz); 
        }
    }   
     
    model_internal static function initRemoteClassAliasAllRelated() : void 
    {
        valueObjects.Timestamp.initRemoteClassAliasSingleChild();
    }

	model_internal var _dminternal_model : _PlanAdjustApplicationEntityMetadata;

	/**
	 * properties
	 */
	private var _internal_lastModifiedTime : Date;
	private var _internal_provinceCode : String;
	private var _internal_adjust_yishuli : int;
	private var _internal_applicationId : String;
	private var _internal_remoteAdjustOperator : String;
	private var _internal_isAvailable : int;
	private var _internal_original_wenshi : int;
	private var _internal_id : Number;
	private var _internal_localAdjustOperator : String;
	private var _internal_localAdjustCommnet : String;
	private var _internal_adjust_yishuwen : int;
	private var _internal_chairmanComment : String;
	private var _internal_province : String;
	private var _internal_original_ligong : int;
	private var _internal_chairmanApproved : int;
	private var _internal_applicationComment : String;
	private var _internal_leibie : String;
	private var _internal_localAdjusted : int;
	private var _internal_original_yishuli : int;
	private var _internal_piciCode : String;
	private var _internal_timeOfRemoteAdjust : Date;
	private var _internal_timeOfAdjustIntoMajor : Date;
	private var _internal_pici : String;
	private var _internal_applicantComment : String;
	private var _internal_timeOfApprove : Date;
	private var _internal_chairmanName : String;
	private var _internal_successfullyCompleted : int;
	private var _internal_majorAdjustOperator : String;
	private var _internal_timeOfLocalAdjust : Date;
	private var _internal_original_population : int;
	private var _internal_serialIdToShow : Number;
	private var _internal_remoteAdjusted : int;
	private var _internal_timeOfApplication : Date;
	private var _internal_applicant : String;
	private var _internal_remoteAdjustComment : String;
	private var _internal_adjust_wenshi : int;
	private var _internal_original_yishuwen : int;
	private var _internal_adjust_ligong : int;

    private static var emptyArray:Array = new Array();

    /**
     * derived property cache initialization
     */  
    model_internal var _cacheInitialized_isValid:Boolean = false;   
    
	model_internal var _changeWatcherArray:Array = new Array();   

	public function _Super_PlanAdjustApplication() 
	{	
		_model = new _PlanAdjustApplicationEntityMetadata(this);
	
		// Bind to own data properties for cache invalidation triggering  
       
	}

    /**
     * data property getters
     */
	[Bindable(event="propertyChange")] 
    public function get lastModifiedTime() : Date    
    {
            return _internal_lastModifiedTime;
    }    
	[Bindable(event="propertyChange")] 
    public function get provinceCode() : String    
    {
            return _internal_provinceCode;
    }    
	[Bindable(event="propertyChange")] 
    public function get adjust_yishuli() : int    
    {
            return _internal_adjust_yishuli;
    }    
	[Bindable(event="propertyChange")] 
    public function get applicationId() : String    
    {
            return _internal_applicationId;
    }    
	[Bindable(event="propertyChange")] 
    public function get remoteAdjustOperator() : String    
    {
            return _internal_remoteAdjustOperator;
    }    
	[Bindable(event="propertyChange")] 
    public function get isAvailable() : int    
    {
            return _internal_isAvailable;
    }    
	[Bindable(event="propertyChange")] 
    public function get original_wenshi() : int    
    {
            return _internal_original_wenshi;
    }    
	[Bindable(event="propertyChange")] 
    public function get id() : Number    
    {
            return _internal_id;
    }    
	[Bindable(event="propertyChange")] 
    public function get localAdjustOperator() : String    
    {
            return _internal_localAdjustOperator;
    }    
	[Bindable(event="propertyChange")] 
    public function get localAdjustCommnet() : String    
    {
            return _internal_localAdjustCommnet;
    }    
	[Bindable(event="propertyChange")] 
    public function get adjust_yishuwen() : int    
    {
            return _internal_adjust_yishuwen;
    }    
	[Bindable(event="propertyChange")] 
    public function get chairmanComment() : String    
    {
            return _internal_chairmanComment;
    }    
	[Bindable(event="propertyChange")] 
    public function get province() : String    
    {
            return _internal_province;
    }    
	[Bindable(event="propertyChange")] 
    public function get original_ligong() : int    
    {
            return _internal_original_ligong;
    }    
	[Bindable(event="propertyChange")] 
    public function get chairmanApproved() : int    
    {
            return _internal_chairmanApproved;
    }    
	[Bindable(event="propertyChange")] 
    public function get applicationComment() : String    
    {
            return _internal_applicationComment;
    }    
	[Bindable(event="propertyChange")] 
    public function get leibie() : String    
    {
            return _internal_leibie;
    }    
	[Bindable(event="propertyChange")] 
    public function get localAdjusted() : int    
    {
            return _internal_localAdjusted;
    }    
	[Bindable(event="propertyChange")] 
    public function get original_yishuli() : int    
    {
            return _internal_original_yishuli;
    }    
	[Bindable(event="propertyChange")] 
    public function get piciCode() : String    
    {
            return _internal_piciCode;
    }    
	[Bindable(event="propertyChange")] 
    public function get timeOfRemoteAdjust() : Date    
    {
            return _internal_timeOfRemoteAdjust;
    }    
	[Bindable(event="propertyChange")] 
    public function get timeOfAdjustIntoMajor() : Date    
    {
            return _internal_timeOfAdjustIntoMajor;
    }    
	[Bindable(event="propertyChange")] 
    public function get pici() : String    
    {
            return _internal_pici;
    }    
	[Bindable(event="propertyChange")] 
    public function get applicantComment() : String    
    {
            return _internal_applicantComment;
    }    
	[Bindable(event="propertyChange")] 
    public function get timeOfApprove() : Date    
    {
            return _internal_timeOfApprove;
    }    
	[Bindable(event="propertyChange")] 
    public function get chairmanName() : String    
    {
            return _internal_chairmanName;
    }    
	[Bindable(event="propertyChange")] 
    public function get successfullyCompleted() : int    
    {
            return _internal_successfullyCompleted;
    }    
	[Bindable(event="propertyChange")] 
    public function get majorAdjustOperator() : String    
    {
            return _internal_majorAdjustOperator;
    }    
	[Bindable(event="propertyChange")] 
    public function get timeOfLocalAdjust() : Date    
    {
            return _internal_timeOfLocalAdjust;
    }    
	[Bindable(event="propertyChange")] 
    public function get original_population() : int    
    {
            return _internal_original_population;
    }    
	[Bindable(event="propertyChange")] 
    public function get serialIdToShow() : Number    
    {
            return _internal_serialIdToShow;
    }    
	[Bindable(event="propertyChange")] 
    public function get remoteAdjusted() : int    
    {
            return _internal_remoteAdjusted;
    }    
	[Bindable(event="propertyChange")] 
    public function get timeOfApplication() : Date    
    {
            return _internal_timeOfApplication;
    }    
	[Bindable(event="propertyChange")] 
    public function get applicant() : String    
    {
            return _internal_applicant;
    }    
	[Bindable(event="propertyChange")] 
    public function get remoteAdjustComment() : String    
    {
            return _internal_remoteAdjustComment;
    }    
	[Bindable(event="propertyChange")] 
    public function get adjust_wenshi() : int    
    {
            return _internal_adjust_wenshi;
    }    
	[Bindable(event="propertyChange")] 
    public function get original_yishuwen() : int    
    {
            return _internal_original_yishuwen;
    }    
	[Bindable(event="propertyChange")] 
    public function get adjust_ligong() : int    
    {
            return _internal_adjust_ligong;
    }    

    /**
     * data property setters
     */      
    public function set lastModifiedTime(value:Date) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:Date = _internal_lastModifiedTime;               
        if (oldValue !== value)
        {
            _internal_lastModifiedTime = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "lastModifiedTime", oldValue, _internal_lastModifiedTime));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set provinceCode(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_provinceCode;               
        if (oldValue !== value)
        {
            _internal_provinceCode = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "provinceCode", oldValue, _internal_provinceCode));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set adjust_yishuli(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_adjust_yishuli;               
        if (oldValue !== value)
        {
            _internal_adjust_yishuli = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "adjust_yishuli", oldValue, _internal_adjust_yishuli));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set applicationId(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_applicationId;               
        if (oldValue !== value)
        {
            _internal_applicationId = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "applicationId", oldValue, _internal_applicationId));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set remoteAdjustOperator(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_remoteAdjustOperator;               
        if (oldValue !== value)
        {
            _internal_remoteAdjustOperator = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "remoteAdjustOperator", oldValue, _internal_remoteAdjustOperator));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set isAvailable(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_isAvailable;               
        if (oldValue !== value)
        {
            _internal_isAvailable = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "isAvailable", oldValue, _internal_isAvailable));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set original_wenshi(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_original_wenshi;               
        if (oldValue !== value)
        {
            _internal_original_wenshi = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "original_wenshi", oldValue, _internal_original_wenshi));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set id(value:Number) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:Number = _internal_id;               
        if (oldValue !== value)
        {
            _internal_id = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "id", oldValue, _internal_id));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set localAdjustOperator(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_localAdjustOperator;               
        if (oldValue !== value)
        {
            _internal_localAdjustOperator = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "localAdjustOperator", oldValue, _internal_localAdjustOperator));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set localAdjustCommnet(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_localAdjustCommnet;               
        if (oldValue !== value)
        {
            _internal_localAdjustCommnet = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "localAdjustCommnet", oldValue, _internal_localAdjustCommnet));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set adjust_yishuwen(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_adjust_yishuwen;               
        if (oldValue !== value)
        {
            _internal_adjust_yishuwen = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "adjust_yishuwen", oldValue, _internal_adjust_yishuwen));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set chairmanComment(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_chairmanComment;               
        if (oldValue !== value)
        {
            _internal_chairmanComment = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "chairmanComment", oldValue, _internal_chairmanComment));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set province(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_province;               
        if (oldValue !== value)
        {
            _internal_province = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "province", oldValue, _internal_province));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set original_ligong(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_original_ligong;               
        if (oldValue !== value)
        {
            _internal_original_ligong = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "original_ligong", oldValue, _internal_original_ligong));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set chairmanApproved(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_chairmanApproved;               
        if (oldValue !== value)
        {
            _internal_chairmanApproved = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "chairmanApproved", oldValue, _internal_chairmanApproved));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set applicationComment(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_applicationComment;               
        if (oldValue !== value)
        {
            _internal_applicationComment = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "applicationComment", oldValue, _internal_applicationComment));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set leibie(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_leibie;               
        if (oldValue !== value)
        {
            _internal_leibie = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "leibie", oldValue, _internal_leibie));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set localAdjusted(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_localAdjusted;               
        if (oldValue !== value)
        {
            _internal_localAdjusted = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "localAdjusted", oldValue, _internal_localAdjusted));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set original_yishuli(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_original_yishuli;               
        if (oldValue !== value)
        {
            _internal_original_yishuli = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "original_yishuli", oldValue, _internal_original_yishuli));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set piciCode(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_piciCode;               
        if (oldValue !== value)
        {
            _internal_piciCode = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "piciCode", oldValue, _internal_piciCode));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set timeOfRemoteAdjust(value:Date) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:Date = _internal_timeOfRemoteAdjust;               
        if (oldValue !== value)
        {
            _internal_timeOfRemoteAdjust = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "timeOfRemoteAdjust", oldValue, _internal_timeOfRemoteAdjust));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set timeOfAdjustIntoMajor(value:Date) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:Date = _internal_timeOfAdjustIntoMajor;               
        if (oldValue !== value)
        {
            _internal_timeOfAdjustIntoMajor = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "timeOfAdjustIntoMajor", oldValue, _internal_timeOfAdjustIntoMajor));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set pici(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_pici;               
        if (oldValue !== value)
        {
            _internal_pici = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "pici", oldValue, _internal_pici));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set applicantComment(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_applicantComment;               
        if (oldValue !== value)
        {
            _internal_applicantComment = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "applicantComment", oldValue, _internal_applicantComment));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set timeOfApprove(value:Date) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:Date = _internal_timeOfApprove;               
        if (oldValue !== value)
        {
            _internal_timeOfApprove = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "timeOfApprove", oldValue, _internal_timeOfApprove));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set chairmanName(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_chairmanName;               
        if (oldValue !== value)
        {
            _internal_chairmanName = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "chairmanName", oldValue, _internal_chairmanName));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set successfullyCompleted(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_successfullyCompleted;               
        if (oldValue !== value)
        {
            _internal_successfullyCompleted = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "successfullyCompleted", oldValue, _internal_successfullyCompleted));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set majorAdjustOperator(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_majorAdjustOperator;               
        if (oldValue !== value)
        {
            _internal_majorAdjustOperator = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "majorAdjustOperator", oldValue, _internal_majorAdjustOperator));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set timeOfLocalAdjust(value:Date) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:Date = _internal_timeOfLocalAdjust;               
        if (oldValue !== value)
        {
            _internal_timeOfLocalAdjust = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "timeOfLocalAdjust", oldValue, _internal_timeOfLocalAdjust));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set original_population(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_original_population;               
        if (oldValue !== value)
        {
            _internal_original_population = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "original_population", oldValue, _internal_original_population));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set serialIdToShow(value:Number) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:Number = _internal_serialIdToShow;               
        if (oldValue !== value)
        {
            _internal_serialIdToShow = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "serialIdToShow", oldValue, _internal_serialIdToShow));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set remoteAdjusted(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_remoteAdjusted;               
        if (oldValue !== value)
        {
            _internal_remoteAdjusted = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "remoteAdjusted", oldValue, _internal_remoteAdjusted));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set timeOfApplication(value:Date) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:Date = _internal_timeOfApplication;               
        if (oldValue !== value)
        {
            _internal_timeOfApplication = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "timeOfApplication", oldValue, _internal_timeOfApplication));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set applicant(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_applicant;               
        if (oldValue !== value)
        {
            _internal_applicant = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "applicant", oldValue, _internal_applicant));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set remoteAdjustComment(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_remoteAdjustComment;               
        if (oldValue !== value)
        {
            _internal_remoteAdjustComment = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "remoteAdjustComment", oldValue, _internal_remoteAdjustComment));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set adjust_wenshi(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_adjust_wenshi;               
        if (oldValue !== value)
        {
            _internal_adjust_wenshi = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "adjust_wenshi", oldValue, _internal_adjust_wenshi));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set original_yishuwen(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_original_yishuwen;               
        if (oldValue !== value)
        {
            _internal_original_yishuwen = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "original_yishuwen", oldValue, _internal_original_yishuwen));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set adjust_ligong(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_adjust_ligong;               
        if (oldValue !== value)
        {
            _internal_adjust_ligong = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "adjust_ligong", oldValue, _internal_adjust_ligong));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    

    /**
     * data property setter listeners
     */   

   model_internal function setterListenerAnyConstraint(value:flash.events.Event):void
   {
        if (model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }        
   }   

    /**
     * valid related derived properties
     */
    model_internal var _isValid : Boolean;
    model_internal var _invalidConstraints:Array = new Array();
    model_internal var _validationFailureMessages:Array = new Array();

    /**
     * derived property calculators
     */

    /**
     * isValid calculator
     */
    model_internal function calculateIsValid():Boolean
    {
        var violatedConsts:Array = new Array();    
        var validationFailureMessages:Array = new Array();    


		var styleValidity:Boolean = true;
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
    
        model_internal::_cacheInitialized_isValid = true;
        model_internal::invalidConstraints_der = violatedConsts;
        model_internal::validationFailureMessages_der = validationFailureMessages;
        return violatedConsts.length == 0 && styleValidity;
    }  

    /**
     * derived property setters
     */

    model_internal function set isValid_der(value:Boolean) : void
    {
       	var oldValue:Boolean = model_internal::_isValid;               
        if (oldValue !== value)
        {
        	model_internal::_isValid = value;
        	_model.model_internal::fireChangeEvent("isValid", oldValue, model_internal::_isValid);
        }        
    }

    /**
     * derived property getters
     */

    [Transient] 
	[Bindable(event="propertyChange")] 
    public function get _model() : _PlanAdjustApplicationEntityMetadata
    {
		return model_internal::_dminternal_model;              
    }	
    
    public function set _model(value : _PlanAdjustApplicationEntityMetadata) : void       
    {
    	var oldValue : _PlanAdjustApplicationEntityMetadata = model_internal::_dminternal_model;               
        if (oldValue !== value)
        {
        	model_internal::_dminternal_model = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "_model", oldValue, model_internal::_dminternal_model));
        }     
    }      

    /**
     * methods
     */  


    /**
     *  services
     */                  
     private var _managingService:com.adobe.fiber.services.IFiberManagingService;
    
     public function set managingService(managingService:com.adobe.fiber.services.IFiberManagingService):void
     {
         _managingService = managingService;
     }                      
     
    model_internal function set invalidConstraints_der(value:Array) : void
    {  
     	var oldValue:Array = model_internal::_invalidConstraints;
     	// avoid firing the event when old and new value are different empty arrays
        if (oldValue !== value && (oldValue.length > 0 || value.length > 0))
        {
            model_internal::_invalidConstraints = value;   
			_model.model_internal::fireChangeEvent("invalidConstraints", oldValue, model_internal::_invalidConstraints);   
        }     	             
    }             
    
     model_internal function set validationFailureMessages_der(value:Array) : void
    {  
     	var oldValue:Array = model_internal::_validationFailureMessages;
     	// avoid firing the event when old and new value are different empty arrays
        if (oldValue !== value && (oldValue.length > 0 || value.length > 0))
        {
            model_internal::_validationFailureMessages = value;   
			_model.model_internal::fireChangeEvent("validationFailureMessages", oldValue, model_internal::_validationFailureMessages);   
        }     	             
    }        
     
     // Individual isAvailable functions     
	// fields, getters, and setters for primitive representations of complex id properties

}

}
